package com.example.util.common;


import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.math.BigDecimal;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;

/**
 * @author Simon
 * @version 0.1
 * @application
 * @Copyright 上海危网信息科技有限公司版权所有
 * @company wwsoft
 * @time 2018年12月29日 下午3:58:47
 */
public class UtilTools {

    /**
     * 无参的构造方法
     */
    public UtilTools() {
        super();
    }

    /**
     * 获取当前日期以及星期基础信息
     * @return YYYY年MM月DD日 星期X
     * @author Simon
     * @timer 2007-05-01
     */
    public static String getFormatDateByWeek() {
        Calendar calendar = Calendar.getInstance();
        int year = calendar.get(Calendar.YEAR);
        int month = calendar.get(Calendar.MONTH) + 1;
        int date = calendar.get(Calendar.DATE);
        int week = calendar.get(Calendar.DAY_OF_WEEK);
        String result = year + "年";
        if (month < 10)
            result += "0" + month + "月";
        else
            result += month + "月";
        if (date < 10)
            result += "0" + date + "日";
        else
            result += date + "日";
        switch (week) {
            case 2: {
                result += " 星期一";
                break;
            }
            case 3: {
                result += " 星期二";
                break;
            }
            case 4: {
                result += " 星期三";
                break;
            }
            case 5: {
                result += " 星期四";
                break;
            }
            case 6: {
                result += " 星期五";
                break;
            }
            case 7: {
                result += " 星期六";
                break;
            }
            case 1: {
                result += " 星期天";
                break;
            }
        }
        return result;
    }

    /**
     * 根据参数要求返回特定格式时间字符串
     * <p>
     * 这种方式得到时间结果有个缺陷（比如当前时针指向6时，得到结果是"6"，而不是"06"）
     * @param flag 指定结果字符串格式
     *             flag = true : yyyy-mm-dd hh24:mi:ss
     *             flag = false :yyyy-mm-dd
     * @return 特定格式时间字符串
     * @author Simon
     * @timer 2007-05-01
     */
    public static String getFormatDate(Boolean flag) {
        return getFormatDate(Calendar.getInstance(), flag);
    }

    /**
     * 根据参数要求返回目录格式时间字符串
     * @param flag 指定结果字符串格式
     *             flag = true : yyyy/mm/dd/hh24/mi/ss/
     *             flag = false: yyyy/mm/dd/
     * @return 特定格式时间字符串
     * @author Simon
     * @timer 2007-05-01
     */
    public static String getFormatDateByDirectory(Boolean flag) {
        String result = UtilTools.getFormatDate(Calendar.getInstance(), flag);
        result = result.replaceAll("-", "/");
        result = result.replaceAll(" ", "/");
        result = result.replaceAll(":", "/");
        return result + "/";
    }

    /**
     * 将Java.util.Date转化为String类型时间
     * @param date java.util.Date 时间实例
     * @return 格式化的时间字符串（yyyy-mm-dd hh24:mi:ss）
     * @author Simon
     * @timer 2007-05-01
     */
    public static String getFormatDate(Date date) {
        return DateFormat.getDateTimeInstance().format(date);
    }

    /**
     * 将Calendar时间转化为特定格式时间字符串
     * @param calendar java.util.Calendar时间实例
     * @param flag     指定结果字符串格式
     *                 flag = true : yyyy-mm-dd hh24:mi:ss
     *                 flag = false :yyyy-mm-dd
     * @return 特定格式时间字符串
     * @author Simon
     * @timer 2007-05-01
     */
    public static String getFormatDate(Calendar calendar, Boolean flag) {
        StringBuilder date = new StringBuilder();
        date.append(calendar.get(Calendar.YEAR));
        date.append("-");
        int temp = calendar.get(Calendar.MONTH) + 1;
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        date.append("-");
        temp = calendar.get(Calendar.DATE);
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        // 返回： YYYY-MM-DD
        if (flag == false) {
            return date.toString();
        }
        date.append(" ");
        temp = calendar.get(Calendar.HOUR_OF_DAY);
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        date.append(":");
        temp = calendar.get(Calendar.MINUTE);
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        date.append(":");
        temp = calendar.get(Calendar.SECOND);
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        return date.toString();
    }

    /**
     * 将Java.util.Calendar转化为String类型时间(得到每个月的第一天和最后一天的日期)
     * @param flag java.util.Calendar 时间实例
     * @return 格式化的时间字符串（yyyy-mm-dd）
     * @author Simon
     * @timer 2007-05-01
     */
    public static String getFormatMonthDate(Boolean flag) {
        String monthDate = "";
        Calendar calendar = new GregorianCalendar();
        SimpleDateFormat simpleFormate = new SimpleDateFormat("yyyy-MM-dd");
        if (flag) {
            // 本月的第一天
            calendar.set(Calendar.DATE, 1);
            monthDate = simpleFormate.format(calendar.getTime());
        } else {
            // 本月的最后一天
            calendar.set(Calendar.DATE, 1);
            calendar.roll(Calendar.DATE, -1);
            monthDate = simpleFormate.format(calendar.getTime());
        }
        return monthDate;
    }

    /**
     * 在当前时间基础上按固定字符串格式获取一个过去或者将来的字符串时间
     * @param flag     指定返回时间字符串格式
     *                 flag = true : yyyy-mm-dd hh24:mi:ss
     *                 flag = false :yyyy-mm-dd
     * @param timeType 时间运算单位信息【0=无运算、1=秒运算、2=分运算、3=时运算、4=天运算、5=月运算、6=年运算】
     * @param number   运算时间量【整数】
     * @return 格式化的时间字符串
     * @author Simon
     * @timer 2007-05-01
     */
    public static String getFormatDate(Boolean flag, int timeType, int number) {
        /** 等到一个当前时间 */
        Calendar calendar = Calendar.getInstance();
        /** 计算过去或者将来时间 */
        if (timeType == 1) {
            calendar.add(Calendar.SECOND, number);// 增减秒数
        } else if (timeType == 2) {
            calendar.add(Calendar.MINUTE, number);// 增减分数
        } else if (timeType == 3) {
            calendar.add(Calendar.HOUR_OF_DAY, number);// 增减时数
        } else if (timeType == 4) {
            calendar.add(Calendar.DATE, number);// 增减天数
        } else if (timeType == 5) {
            calendar.add(Calendar.MONTH, number);// 增减月份
        } else if (timeType == 6) {
            calendar.add(Calendar.YEAR, number);// 增减年份
        } else if (timeType != 0) {
            return null;
        }
        /** 获取字符串时间 */
        StringBuilder date = new StringBuilder();
        date.append(calendar.get(Calendar.YEAR));
        date.append("-");
        int temp = calendar.get(Calendar.MONTH) + 1;
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        date.append("-");
        temp = calendar.get(Calendar.DATE);
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        // 返回： YYYY-MM-DD
        if (flag == false) {
            return date.toString();
        }
        date.append(" ");
        temp = calendar.get(Calendar.HOUR_OF_DAY);
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        date.append(":");
        temp = calendar.get(Calendar.MINUTE);
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        date.append(":");
        temp = calendar.get(Calendar.SECOND);
        if (temp < 10)
            date.append("0" + temp);
        else
            date.append(temp);
        return date.toString();
    }

    /**
     * 指定日期字符串n天之前或者之后的日期
     * @param datestr 日期字符串
     * @param day     相对天数，为正数表示之后，为负数表示之前
     * @return 指定日期字符串n天之前或者之后的日期
     */
    public static Date getBeforeAfterDate(String datestr, int day) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        java.sql.Date olddate = null;
        try {
            df.setLenient(false);
            olddate = new java.sql.Date(df.parse(datestr).getTime());
        } catch (Exception e) {
            throw new RuntimeException("日期转换错误");
        }
        Calendar cal = new GregorianCalendar();
        cal.setTime(olddate);
        int Year = cal.get(Calendar.YEAR);
        int Month = cal.get(Calendar.MONTH);
        int Day = cal.get(Calendar.DAY_OF_MONTH);
        int NewDay = Day + day;
        cal.set(Calendar.YEAR, Year);
        cal.set(Calendar.MONTH, Month);
        cal.set(Calendar.DAY_OF_MONTH, NewDay);

        return new java.sql.Date(cal.getTimeInMillis());
    }

    /**
     * 指定日期基础上按固定字符串格式获取一个过去或者将来的字符串时间
     * @param datestr  日期字符串
     * @param timeType 时间运算单位信息【0=无运算、1=秒运算、2=分运算、3=时运算、4=天运算、5=月运算、6=年运算】
     * @param number   运算时间量【整数】
     * @return
     */
    public static Date getBeforeAfterDate(String datestr, int timeType, int number) {
        SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd");
        java.sql.Date olddate = null;
        try {
            df.setLenient(false);
            olddate = new java.sql.Date(df.parse(datestr).getTime());
        } catch (Exception e) {
            throw new RuntimeException("日期转换错误");
        }
        Calendar calendar = new GregorianCalendar();
        calendar.setTime(olddate);
        /** 计算过去或者将来时间 */
        if (timeType == 1) {
            calendar.add(Calendar.SECOND, number);// 增减秒数
        } else if (timeType == 2) {
            calendar.add(Calendar.MINUTE, number);// 增减分数
        } else if (timeType == 3) {
            calendar.add(Calendar.HOUR_OF_DAY, number);// 增减时数
        } else if (timeType == 4) {
            calendar.add(Calendar.DATE, number);// 增减天数
        } else if (timeType == 5) {
            calendar.add(Calendar.MONTH, number);// 增减月份
        } else if (timeType == 6) {
            calendar.add(Calendar.YEAR, number);// 增减年份
        } else if (timeType != 0) {
            return null;
        }
        return new java.sql.Date(calendar.getTimeInMillis());
    }

    /**
     * 得到两个时间相差的天数
     * @param startDate
     * @param endDate
     * @return
     * @throws IOException
     */
    public static Long getCalculatedDays(Date startDate, Date endDate) throws IOException {
        Long days = 0L;
        try {
            Long diff = startDate.getTime() - endDate.getTime();
            days = diff / (1000 * 60 * 60 * 24);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return days;
    }

    /**
     * MD5加密算法
     * @param source 原加密字符串
     * @return String 加密后的字符串
     * @throws NoSuchAlgorithmException
     * @author Simon
     * @timer 2007-05-01
     */
    public static String MD5(String source) throws NoSuchAlgorithmException {
        if (source == null || source.length() == 0) {
            System.err.println("警告 ： 空字符串不可以作MD5加密 !");
            return null;
        }
        StringBuffer hexString = new StringBuffer();
        try {
            MessageDigest md = MessageDigest.getInstance("MD5");
            md.update(source.getBytes());
            byte hash[] = md.digest();
            for (int i = 0; i < hash.length; i++) {
                if ((0xff & hash[i]) < 0x10) {
                    hexString.append("0" + Integer.toHexString((0xFF & hash[i])));
                } else {
                    hexString.append(Integer.toHexString(0xFF & hash[i]));
                }
            }
            return hexString.toString();
        } catch (NoSuchAlgorithmException e) {
            System.err.println("当请求特定的加密算法<MD5>而它在该环境中不可用时抛出此异常");
            throw new NoSuchAlgorithmException("当请求特定的加密算法<MD5>而它在该环境中不可用时抛出此异常");
        }
    }



    /**
     * 字符串合并函数
     * @param source    [] 需要合并的字符串集合
     * @param separator 合并字符串的分割符号
     * @return 合并完毕字符串信息
     * @author Simon
     * @timer 2007-05-01
     */
    public static String mergeString(String source[], String separator) {
        if (source == null || separator == null || source.length == 0)
            return "";
        StringBuilder str = new StringBuilder();
        for (int i = 0; i < source.length; i++) {
            str.append(source[i]);
            if (i + 1 != source.length)
                str.append(separator);
        }
        return str.toString();
    }

    /**
     * 子字符串个数统计函数
     * @param source    源字符串
     * @param separator 字符串的分割符号
     * @return int = 子字符串个数
     * @author Simon
     * @timer 2007-05-01
     */
    public static int countString(Boolean countFlag, String source, String separator) {
        if (source == null || source.length() == 0) {
            return 0;
        }
        StringTokenizer token = new StringTokenizer(source, separator);
        return token.countTokens();
    }

    /**
     * 字符串解析函数
     * @param source    源字符串
     * @param separator 字符串分割符
     * @return ArrayList<String> = 子字符串集合
     * @author Simon
     * @timer 2007-05-01
     */
    public static ArrayList<String> analysisStringForArrayList(String source, String separator) {
        if (source == null || source.length() == 0) {
            return null;
        }
        StringTokenizer token = new StringTokenizer(source, separator);
        ArrayList<String> list = new ArrayList<String>(token.countTokens());
        while (token.hasMoreElements()) {
            list.add(token.nextToken());
        }

        return list;
    }

    /**
     * 字符串解析函数
     * @param source    源字符串
     * @param separator 字符串分割符
     * @return 子字符串数组
     * @author Simon
     * @timer 2007-05-01
     */
    public static String[] analysisStringForArray(String source, String separator) {
        if (source == null || source.length() == 0) {
            return null;
        }
        StringTokenizer token = new StringTokenizer(source, separator);
        String array[] = new String[token.countTokens()];
        int arrayFlag = 0;
        while (token.hasMoreElements()) {
            array[arrayFlag++] = token.nextToken();
        }
        return array;
    }

    /**
     * 字符集转换函数
     * @param source       需要编码的字符串
     * @param sourceCoding 源编码
     * @param targetCoding 目标编码
     * @return 转换编码后的字符串
     * @throws UnsupportedEncodingException
     * @author Simon
     * @timer 2007-05-01
     */
    public static String StringCoding(String source, String sourceCoding, String targetCoding)
            throws UnsupportedEncodingException {
        if (source != null)
            return source = new String(source.getBytes(sourceCoding), targetCoding);
        return "";
    }

    /**
     * 将平台默认的字符编码转化为ISO-8859-1编码
     * @param source 需要编码的字符串
     * @return String 编码后的字符串
     * @throws UnsupportedEncodingException
     * @author Simon
     * @timer 2007-05-01
     */
    public static String StringCodingTo8859(String source) throws UnsupportedEncodingException {
        if (source != null)
            return new String(source.getBytes(), "ISO-8859-1");
        return "";
    }

    /**
     * 根据指定字符串长度获取一个随机数字字符串
     * @param strlen = 字符串长度
     * @return 一个随机数字字符串
     * @author Simon
     * @timer 2007-08-07
     */
    public static String getRandomNumberString(int strlen) {
        Random rd = new Random();
        StringBuilder rstr = new StringBuilder();
        for (int i = 0; i < strlen; i++) {
            rstr.append(rd.nextInt(10));
        }
        return rstr.toString();
    }

    /**
     * 获取一个随机的字母
     * @param flag = true/false : 大写字母/小写字母
     * @return 英文字母
     * @author Simon
     * @timer 2007-06-10
     */
    public static char getRanDomCharacter(Boolean flag) {
        int rd = 0;
        while (true) {
            rd = new Random().nextInt(27);
            if (rd != 0) {
                if (flag == true) {
                    return (char) (64 + rd);
                } else {
                    return (char) (96 + rd);
                }
            }
        }
    }

    /**
     * 根据检索参数构建条件语句
     * @param parameter [][]
     *                  parameter[N][5] = 参数详细信息;
     *                  parameter[N][0]=属性名称
     *                  parameter[N][1]=属性值
     *                  parameter[N][2]=数学运算符号（>、>=、=、<、<=、LIKE）
     *                  parameter[N][3]=属性值类型（数字类型：NUMERIC,字符串：STRING,时间类型:DATE{YYYY-MM-DD或者YYYY-MM-DD HH24:MI:SS})
     *                  parameter[N][4]=逻辑运算符（必须全部是AND或者全部是OR）
     * @return 数据库检索条件语句
     * @throws NullPointerException
     * @author Simon
     * @timer 2009-06-10
     */
    public static String constructParameterSql(String parameter[][]) throws NullPointerException {
        if (parameter == null || parameter.length == 0) {
            throw new NullPointerException("根据检索参数构建条件语句时：parameter[][] = java.lang.NullPointerException !");
        }
        StringBuilder condition = new StringBuilder("WHERE ");
        for (int i = 0; i < parameter.length; i++) {
            if (i != 0) {
                condition.append(" " + parameter[i][4] + " ");
            }
            if (parameter[i][3].toUpperCase().equals("NUMERIC")) {
                condition.append(parameter[i][0] + parameter[i][2] + parameter[i][1]);
            } else if (parameter[i][3].toUpperCase().equals("STRING")) {
                condition.append(parameter[i][0] + parameter[i][2] + "'" + parameter[i][1] + "'");
            } else if (parameter[i][1].length() == 10) {
                condition.append("TO_CHAR(" + parameter[i][0] + ",'YYYY-MM-DD')" + parameter[i][2] + "'"
                        + parameter[i][1] + "'");
            } else if (parameter[i][1].length() == 19) {
                condition.append("TO_CHAR(" + parameter[i][0] + ",'YYYY-MM-DD HH24:MI:SS')" + parameter[i][2] + "'"
                        + parameter[i][1] + "'");
            } else {
                return null;
            }
        }
        return condition.toString();
    }

    /**
     * 数字转换为带分隔符的字符串，及在百位、十万。。等前一位加上"," 如source="1234567" return "1,234,567"
     */
    public static String atuoAddComma(String source) {
        String numeric = "";
        if (source != "" && source.length() > 3) {
            int neg = 0;
            if (source.indexOf("-") == 0) {
                source = source.replace("-", "");
                neg = 1;
            }
            int digit = source.length();
            int residue = digit % 3;// 取出前面还有几位数据
            int divisor = digit / 3;// 得到总共有几对3位数字

            if (residue != 0) {
                numeric = source.substring(0, residue);
                source = source.substring(residue, digit);
            }
            for (int i = 1; i <= divisor; i++) {
                if (residue == 0 && i == 1) {
                    numeric = numeric + source.substring(3 * (i - 1), 3 * i);
                } else {
                    numeric = numeric + "," + source.substring(3 * (i - 1), 3 * i);
                }
            }
            if (neg == 1) {
                numeric = "-" + numeric;
            }
        } else {
            numeric = source;
        }
        return numeric;
    }

    /**
     * 数字转换为大写数字
     * @param value 小写数字 如123456
     * @return 数字的大写
     * @author Simon
     * @timer 2007-06-10
     */
    public static String changeToBig(double value) {
        char[] hunit = {'拾', '佰', '仟'}; // 段内位置表示
        char[] vunit = {'万', '亿'}; // 段名表示
        char[] digit = {'零', '壹', '贰', '叁', '肆', '伍', '陆', '柒', '捌', '玖'}; // 数字表示
        long midVal = (long) (value * 100 + 0.5); // 转化成整形,四舍五入
        String valStr = String.valueOf(midVal); // 转化成字符串
        String prefix = ""; // 整数部分转化的结果
        String suffix = ""; // 小数部分转化的结果
        if (valStr.equals("0")) {
            prefix = "";
            suffix = "零";
        } else {
            String head = valStr.substring(0, valStr.length() - 2); // 取整数部分
            String rail = valStr.substring(valStr.length() - 2); // 取小数部分
            // 处理小数点后面的数
            if (rail.equals("00")) { // 如果小数部分为0
                suffix = "整";
            } else {
                suffix = digit[rail.charAt(0) - '0'] + "角" + digit[rail.charAt(1) - '0'] + "分"; // 否则把角分转化出来
            }
            // 处理小数点前面的数
            char[] chDig = head.toCharArray(); // 把整数部分转化成字符数组
            boolean preZero = false; // 标志当前位的上一位是否为有效0位（如万位的0对千位无效）
            byte zeroSerNum = 0; // 连续出现0的次数
            for (int i = 0; i < chDig.length; i++) { // 循环处理每个数字
                int idx = (chDig.length - i - 1) % 4; // 取段内位置
                int vidx = (chDig.length - i - 1) / 4; // 取段位置

                if (chDig[i] == '0') { // 如果当前字符是0
                    preZero = true;
                    zeroSerNum++; // 连续0次数递增
                    if (idx == 0 && vidx > 0 && zeroSerNum < 4) {
                        prefix += vunit[vidx - 1];
                        preZero = false; // 不管上一位是否为0，置为无效0位
                    }
                } else {
                    zeroSerNum = 0; // 连续0次数清零
                    if (preZero) { // 上一位为有效0位
                        prefix += digit[0]; // 只有在这地方用到'零'
                        preZero = false;
                    }
                    prefix += digit[chDig[i] - '0']; // 转化该数字表示
                    if (idx > 0)
                        prefix += hunit[idx - 1];
                    if (idx == 0 && vidx > 0) {
                        prefix += vunit[(vidx + 1) % 2];
                        for (int j = 0; j < (vidx + 1) / 2 - 1; j++) {
                            prefix += vunit[1];
                        }
                    }
                }
            }
            if (prefix.length() > 0)
                prefix += '元'; // 如果整数部分存在,则有元的字样
        }
        return prefix + suffix; // 返回正确表示
    }

    /**
     * 提供精确的加法运算。
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */
    public static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */
    public static double sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }

    /**
     * 提供精确的乘法运算。
     * @param v1 被乘数
     * @param v2 乘数
     * @return 两个参数的积
     */
    public static double mul(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.multiply(b2).doubleValue();
    }

    /**
     * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指 定精度，以后的数字四舍五入。
     * @param v1    被除数
     * @param v2    除数
     * @param scale 表示表示需要精确到小数点以后几位。
     * @return 两个参数的商
     */
    public static double div(double v1, double v2, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.divide(b2, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 提供精确的小数位四舍五入处理。
     * @param v     需要四舍五入的数字
     * @param scale 小数点后保留几位
     * @return 四舍五入后的结果
     */
    public static double round(double v, int scale) {
        if (scale < 0) {
            throw new IllegalArgumentException("The scale must be a positive integer or zero");
        }
        BigDecimal b = new BigDecimal(Double.toString(v));
        BigDecimal one = new BigDecimal("1");
        return b.divide(one, scale, BigDecimal.ROUND_HALF_UP).doubleValue();
    }

    /**
     * 重量单位计量转换相应值
     * @param weightValue   需要转换的重量值
     * @param measuringUnit 计量单位方式，1：吨，2：千克，3：克
     * @param flag          转换方式，true：从其他单位转换为吨，false：从吨转换为其他单位
     */
    public static double weightMeasuringUnitChange(Double weightValue, Long measuringUnit, boolean flag) {
        double returnValue = 0;
        if (weightValue != null) {
            if (flag) {
                if (measuringUnit == 1) {// 吨
                    returnValue = weightValue;
                } else if (measuringUnit == 2) {// 千克
                    returnValue = div(Double.valueOf(weightValue), Double.valueOf("1000"), 3);
                } else if (measuringUnit == 3) {// 克
                    returnValue = div(Double.valueOf(weightValue), Double.valueOf("1000000"), 6);
                }
            } else {
                if (measuringUnit == 1) {// 吨
                    returnValue = weightValue;
                } else if (measuringUnit == 2) {// 千克
                    returnValue = mul(Double.valueOf(weightValue), Double.valueOf("1000"));
                } else if (measuringUnit == 3) {// 克
                    returnValue = mul(Double.valueOf(weightValue), Double.valueOf("1000000"));
                }
            }
        }
        return returnValue;
    }

    /**
     * @param str
     * @param strLength
     * @return
     */
    public static String addZeroForNum(String str, int strLength) {
        int strLen = str.length();
        if (strLen < strLength) {
            while (strLen < strLength) {
                StringBuffer sb = new StringBuffer();
                /** 左补0*/
                sb.append("0").append(str);
                str = sb.toString();
                strLen = str.length();
            }
        }
        return str;
    }

    /**
     * str转date
     * @param date
     * @return
     */
    public static Date formatDate(String date) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
        try {
            Date utilDate = sdf.parse(date);
            return utilDate;
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 汉语中数字大写
     */
    private static final String[] CN_UPPER_NUMBER = {"零", "壹", "贰", "叁", "肆", "伍", "陆", "柒", "捌", "玖"};
    /**
     * 汉语中货币单位大写，这样的设计类似于占位符
     */
    private static final String[] CN_UPPER_MONETRAY_UNIT = {"分", "角", "元", "拾", "佰", "仟", "万", "拾", "佰", "仟", "亿", "拾",
            "佰", "仟", "兆", "拾", "佰", "仟"};
    /**
     * 特殊字符：整
     */
    private static final String CN_FULL = "整";
    /**
     * 特殊字符：负
     */
    private static final String CN_NEGATIVE = "负";
    /**
     * 金额的精度，默认值为2
     */
    private static final int MONEY_PRECISION = 2;
    /**
     * 特殊字符：零元整
     */
    private static final String CN_ZEOR_FULL = "零元" + CN_FULL;

    /**
     * 把输入的金额转换为汉语中人民币的大写
     * @param money 输入的金额
     * @return 对应的汉语大写
     */
    public static String numberToCNMontrayUnit(Double money) {
        BigDecimal numberOfMoney = BigDecimal.valueOf(money);
        StringBuffer sb = new StringBuffer();
        int signum = numberOfMoney.signum();
        // 零元整的情况
        if (signum == 0) {
            return CN_ZEOR_FULL;
        }
        // 这里会进行金额的四舍五入
        long number = numberOfMoney.movePointRight(MONEY_PRECISION).setScale(0, 4).abs().longValue();
        // 得到小数点后两位值
        long scale = number % 100;
        int numUnit = 0;
        int numIndex = 0;
        boolean getZero = false;
        // 判断最后两位数，一共有四中情况：00 = 0, 01 = 1, 10, 11
        if (!(scale > 0)) {
            numIndex = 2;
            number = number / 100;
            getZero = true;
        }
        if ((scale > 0) && (!(scale % 10 > 0))) {
            numIndex = 1;
            number = number / 10;
            getZero = true;
        }
        int zeroSize = 0;
        while (true) {
            if (number <= 0) {
                break;
            }
            // 每次获取到最后一个数
            numUnit = (int) (number % 10);
            if (numUnit > 0) {
                if ((numIndex == 9) && (zeroSize >= 3)) {
                    sb.insert(0, CN_UPPER_MONETRAY_UNIT[6]);
                }
                if ((numIndex == 13) && (zeroSize >= 3)) {
                    sb.insert(0, CN_UPPER_MONETRAY_UNIT[10]);
                }
                sb.insert(0, CN_UPPER_MONETRAY_UNIT[numIndex]);
                sb.insert(0, CN_UPPER_NUMBER[numUnit]);
                getZero = false;
                zeroSize = 0;
            } else {
                ++zeroSize;
                if (!(getZero)) {
                    sb.insert(0, CN_UPPER_NUMBER[numUnit]);
                }
                if (numIndex == 2) {
                    if (number > 0) {
                        sb.insert(0, CN_UPPER_MONETRAY_UNIT[numIndex]);
                    }
                } else if (((numIndex - 2) % 4 == 0) && (number % 1000 > 0)) {
                    sb.insert(0, CN_UPPER_MONETRAY_UNIT[numIndex]);
                }
                getZero = true;
            }
            // 让number每次都去掉最后一个数
            number = number / 10;
            ++numIndex;
        }
        // 如果signum == -1，则说明输入的数字为负数，就在最前面追加特殊字符：负
        if (signum == -1) {
            sb.insert(0, CN_NEGATIVE);
        }
        // 输入的数字小数点后两位为"00"的情况，则要在最后追加特殊字符：整
        if (!(scale > 0)) {
            sb.append(CN_FULL);
        }
        return sb.toString();
    }

    /**
     * SHA256 加密
     * @param str
     * @return
     */
    public static String SHA256(String str){
        String encodeStr="";
        try {
            MessageDigest messageDigest=MessageDigest.getInstance("SHA-256");
            messageDigest.update(str.getBytes("UTF-8"));
            encodeStr=byte2Hex(messageDigest.digest());
        } catch (Exception e) {
            e.printStackTrace();
        }
        return encodeStr;
    }

    private static String byte2Hex(byte[] bytes){
        StringBuffer sb = new StringBuffer();
        String temp = null;
        for (int i=0;i<bytes.length;i++){
            temp = Integer.toHexString(bytes[i] & 0xFF);
            if (temp.length()==1){
                //1得到一位的进行补0操作
                sb.append("0");
            }
            sb.append(temp);
        }
        return sb.toString();
    }
}
